Mathematisches Forschungsinstitut Oberwolfach Eeziente Algorithmen

s Dynamic Algorithms for Graphs of Bounded Treewidth Torben Hagerup The formalism of monadic second-order (MS) logic has been very successful in unifying a large number of algorithms for graphs of bounded treewidth. We extend the elegant framework of MS logic from static problems to dynamic problems, in which queries about MS properties of a graph of bounded treewidth are interspersed with updates of vertex and edge labels. This allows us to unify and occasionally strengthen a number of scattered previous results obtained in an ad-hoc manner and to enable solutions to a wide range of additional problems to be derived automatically. As an auxiliary result of independent interest, we dynamize a data structure of Chazelle for answering queries about sums of labels along paths in a tree with edges labeled by elements of a semigroup. Splitting and Merging Techniques for Order Decomposable Problems, with Applications Giuseppe F. Italiano (joint work with Roberto Grossi) Let S be a set whose items are sorted with respect to d > 1 total orders 1; : : : ; d, and which is subject to dynamic operations, such as insertions of a single item, deletions of a single item, split and concatenate operations performed according to any chosen order i (1 i d). This generalizes to dimension d > 1 the notion of concatenable data structures, such as the 2{3{trees, which support splits and concatenates under a single total order. The main contribution of this paper is a general and novel technique for solving order decomposable problems on S, which yields new and e cient concatenable data structures for dimension d > 1. By using our technique we maintain S with the following time bounds: O(log p) for the insertion or the deletion of a single item, where p is the number of items currently in S; O(p1 1=d) for splits and concatenates along any order, and for rectangular range queries. The space required is O(p). We provide several applications of our technique. First, we present new multidimensional data structures implementing two{dimensional priority queues, two{dimensional search trees, and concatenable interval trees: these data structures allow us to improve many previously known results on decomposable problems under split and concatenate operations, such as membership query, minimum{weight item, range query, convex hulls and Voronoi diagrams. Second, and perhaps a bit surprisingly, we reduce some dynamic graph problems to order decomposable problems. Finally, we show how to make our technique for decomposable problems suitable for e cient external memory implementation. On Sorting Strings in External Memory Paolo Ferragina (joint work with L. Arge, R. Grossi and J. Vitter) 4 In this talk we investigate for the rst time the I/O complexity of the problem of sorting a set of strings in external memory, which is a fundamental component of many large-scale text applications. In the standard unit-cost RAM comparison model, the complexity of sorting K strings of total length N is (K log2K+N). By analogy, in the external memorymodel, where the internal memory has size M and the block transfer size is B, it would be natural to guess that the I/O complexity of sorting strings is (K=B logM=BK=B +N=B), but the known algorithms do not come even close to achieving this bound. Our results show, somewhat counterintuitively, that the I/O complexity of string sorting depends upon the length of the strings relative to the block size. We obtain improved algorithms and in several cases lower bounds that match their I/O bounds. We also develop more practical algorithms without assuming the comparison model and discuss their performance. On Polynomial Ideals, Their Complexity, and Applications Ernst W. Mayr We rst consider binomial ideals over the rationals in the unknowns x1; : : : ; xn. It is known that Grobner bases for such ideals are again binomial and obey a doubly exponential degree bound. We use this bound and another doubly exponential degree bound (due to Herrman/26) for the word problem for nitely presented commutative semigroups to derive an exponential space bound for the following problems: 1. the subword reachability problem in nitely presented commutative semigroups; 2. the problem of computing the minimal elements of an equivalence class in a nitely presented commutative semigroup; 3. the problem of computing the periods of an equivalence class in a nitely presented commutative semigroup; 4. the equivalence problem for nitely presented commutative semigroups; 5. the problem of computing the reduced Grobner bases for a binomial ideal. We then discuss the complexity of computing normal forms and reduced Grobner bases for general ideals (with coe cients in the rationals or nite elds). Here we show that both problems are complete for EXPSPACE, whereas Buchberger's algorithm requires (in the worst case) space doubly exponential in the input size. Dynamic Data Structures for Realtime Management of Large Geometric Scenes Friedhelm Meyer auf der Heide (joint work with Matthias Fischer and Willy B. Strothmann) We present a data structure problem which describes the requirements of a simple variant of fully dynamic walk-through animation: We assume the scene to consist of unit size ball in two or three dimensional space. The scene may be arbitrarily large and has to be stored in secondary memory. We allow a visitor to walk in the scene and a modeller to update the scene by inserting or deleting balls. The data structure has to present all balls within 5 distance t (t is speci ed by the speed of the graphic hardware) to the current visitor's posn, 20 times per second. The updates also have to be executed in real time, i.e., in time independent of the size of the scene. We present a data structure that ful lls these requirements. Preliminary experiments also indicate that it is e cient in practice. Planar Point Location Close to the Information Theoretic Lower Bound Raimund Seidel (joint work with U. Adamy) We show that point location queries in a planar subdivision of size n can be answered in the worst case using at most log2 n+q8 log2 n+O(1) steps, where a step is a comparison of the query point against a line. Such a bound can even be achieved if only O(n) space is allowed. We also show that on a very realistic model of computation point location queries must take in the worst case at least log2 n+q2 log2 n O(1) steps. Added note: During the course of the workshop both the upper and the lower bound were improved. Q(n), the worst case query complexity in a subdivision of size n was shown to satisfy log2 n+2qlog2 n (1=2) log2 log2 n 2 Q(n) log2 n+2qlog2 n+ (1=2) log2 log2 n+2 ; thus narrowing the gap between upper and lower bound to log log n+O(1). Minimum Quadrangulations of Meshes Karsten Weihe (joint work with Matthias M uller-Hannemann) In this talk, a mesh is a nite set of polygons in the three-dimensional space, which are not necessarily plane and together approximate a two-dimensional manifold (or a nite set of manifolds, which must not intersect, but may be incident at so-called folding edges). The problem is to re ne such a mesh by decomposing the polygons such that the re ned mesh solely consists of conformant quadrilaterals and the number of quadrilaterals is minimum. In that, conformant means that any two non-disjoint quadrilaterals either share a single corner or a whole side. This problem is NP-hard. Here we present approximation algorithms. More speci cally, constant factor 4 can be achieved in linear time; if there are no folding edges, factor 3 can be achieved in linear time and factor 28=15 in O(mn log n). E cient Robot Self-Localization in Simple Polygon Sven Schuierer Localization is the process of determining an unknown starting position on a given map. It is an important problem for autonomous mobile robots and has applications in numerous areas ranging from aerial photography to autonomous vehicle exploration. In this paper we present a new fast implementation of a simple strategy for a robot to localize inside a 6 simple polygon. The only information available to the robot is given by its visual sensors. We assume that in this way the robot has access to its local visibility polygon. The simple strategy we consider repeatedly goes to the closest point at which the robot is able to eliminate at least one of the possible positions it may be located at. Our implementation of this strategy runs in time O(kn log n) and space O(kn) where n is number of vertices of the polygon and k the number of possible robot positions at the beginning. Beyond the Flow Decomposition Barrier Andrew V. Goldberg (joint work with Satish Rao) The maximum ow problem is a classical optimization problem that has been intensely studied because of its numerous applications. For a network with n vertices and m arcs, O(nm) is a natural bound for maximum ow algorithms: The size of an explicit ow decomposition gives a matching lower bound. This lower bound does not apply if the decomposition is not needed. No previous maximum ow algorithm, however, runs in O(nm) time. In the unit capacity case, the decomposition size is O(m) and the problem can be solved in O(min(n2=3;m1=2)m) time [Karzanov, Even & Tarjan]. We present an algorithm that signi cantly improves upon the ow decomposition bound unless the input capacities are huge. Our algorithm runs inO(min(n2=3;m1=2)m log n2 m log U) time, assuming the capacities are integers between 1 and U . This bound bridges the gap between the unit capacity case and the case of arbitrary integral capacities. The algorithm is based on a new approach to the maximum ow problem. Annotated Statistical Indices for Sequence Analysis Alberto Apostolico (joint work with F. P. Preparata and, respectively, M. E. Bock and X. Xuyan) We discuss the frequently encountered task of identifying words that are, by some statistical measure, typical or anomalous in the context of larger sequences. Tables for storing the number of occurrences in a string of substrings of (or up to) a given length are routinely computed in applications. Actually, clever methods are available to compute and organize the counts of occurrences of all substrings of a given string. The corresponding tables take up the tree-like structure of a special kind of digital search index or trie. Once the index itself is built, it makes sense to annotate its entries with the expected values and variances that may be associated with them under one or more probabilistic models. One such process of annotation is addressed in this talk. We derive formulae expressing the expected values and variances for substring occurrences, in the hypothesis of a generative process governed by independent, identically distributed random variables. The formulae are then re-structured in a way that is more conducive to e cient computation, in the sense that the expected values and variances of all pre xes of a string can be computed optimally in overall linear time, whence the 7 entire index annotation can be carried out in quadratic time. The heart of the construction exploits the structure of the set of periods of a string, in conjunction with a classical implement of fast string searching known as the \failure function". Exploiting Locality for Data Management in Systems of Limited Bandwidth Berthold Vocking (joint work with B. M. Maggs, F. Meyer auf der Heide, and M. Westermann) Large parallel and distributed systems, including massively parallel processor systems (MPPs) and networks of workstations (NOWs), are usually connected by a network of limited bandwidth. In this paper, we consider the problem of placing and accessing shared objects in such systems. Our focus is on reducing the bandwidth bottleneck, i.e., the congestion, as much as possible by exploiting locality in the pattern of read and write accesses to the objects. Most previous work in this area investigates either hashing or caching based strategies. Hashing distributes the objects uniformly among the processors giving up the locality of the application. Caching exploits locality by minimizing the distances to the accessed objects, which, however, can produce bottlenecks in the network. We present an approach that combines hashing and caching techniques. We introduce static and dynamic strategies. For the static strategies, we assume that frequencies of read and write accesses for all processor-object pairs are given in advance. For the dynamic strategies, we assume no knowledge about the access pattern. We show that our strategies achieve optimal or close-to-optimal congestion for the most relevant classes of bandwidth limited networks, e.g., trees, meshes and clustered networks. Computing Exact Geometric Predicates Using Modular Arithmetic with Single Precision Herv e Bronnimann (joint work with Ioannis Z. Emiris, Sylvain Pion and Victor Y. Pan) We propose an e cient method that determines the sign of a multivariate polynomial expression with integer coe cients. This is a central operation on which the robustness of many geometric algorithms depends. Our method relies on modular computations, for which comparisons are usually thought to require multiprecision. Our novel technique of recursive relaxation of the moduli enables us to carry out sign determination and comparisons by using only oating point computations in single precision. This leads us to propose a hybrid symbolic-numeric approach to exact arithmetic. The method is highly parallelizable and is the fastest of all known multiprecision methods from a complexity point of view. As an application, we show how to compute a few geometric predicates that reduce to matrix determinants and we discuss implementation e ciency, which can be enhanced by arithmetic lters. We substantiate these claims by experimental results and comparisons to other existing approaches. Our method can be used to generate robust and e cient implementations of geometric algorithms (convex hulls, Delaunay triangulations, arrangements) and numerical computer algebra (algebraic representation of curves and points, symbolic perturbation, Sturm sequences and multivariate resultants). 8 Algorithms for the Protein Docking Problem Hans-Peter Lenhof We have developed and implemented a parallel distributed algorithm for the rigid-body protein docking problem. The algorithm is based on a new tness function for evaluating the surface matching of a given conformation. The tness function is de ned as the weighted sum of two contact measures, the geometric contact measure and the chemical contact measure. The geometric contact measure measures the \size" of the contact area of two molecules. It is a potential function that counts the \van der Waals contacts" between the atoms of the two molecules (the algorithm does not compute the Lennard-Jones potential). The chemical contact measure is also based on the \van der Waals contacts" principle: We consider all atom pairs that have a \van der Waals" contact, but instead of adding a constant for each pair (a; b) we add a \chemical weight" that depends on the atom pair (a; b). We tested our docking algorithm with \real world" docking examples and compared the results of our docking algorithm with the results of the best known algorithms. In 32 of 35 test examples the best conformation with respect to the tness function was an approximation of the real conformation. Deterministic Minimum Spanning Trees Bernard Chazelle I will discuss a deterministic algorithm for computing a minimum spanning tree of a weighted graph. Its complexity is O(m log + n), where m, n, and are, respectively, the number of edges, the number of vertices, and the functional inverse of Ackermann's function. No numeric assumptions are made on the edge weights. On a Software Library of Dynamic Graph Algorithms David Alberts We present a project for assembling a library of implementations of dynamic graph algorithms and related tools. It aims at bridging the gap between theoretically interesting algorithms and usable software. The library is based on LEDA and written in C++. It will become available as a LEDA Extension Package (LEP). In the talk we concentrate on some of the practical problems arising in the design and implementation of the library, particularly in keeping the consistency among several graph data structures working on the same dynamically changing graph. For more information and a list of all participating sites and people see http://www.informatik.uni-halle.de/ alberts/lepdga.html. On-line Randomized Edge-Disjoint Paths Stefano Leonardi (joint work with Alberto Marchetti-Spaccamela, Alessio Presciutti and Adi Ros en) We consider the on-line version of the on-line edge-disjoint paths problem on trees and meshes. Previous work gave randomized on-line algorithms for these problems, and proved 9 that they have optimal competitive ratios. However, these algorithms can obtain very low pro t with high probability. We investigate the question of devising for these problems on-line competitive algorithms that also guarantee a \good" solution with \good" probability. We give a new family of randomized algorithms with optimal (up to constant factors) competitive ratios, and provably \good" probability to get a pro t close to the expectation. We complement these results by providing bounds on the probability, of any optimally-competitive randomized on-line algorithm for the problems we consider, to get a pro t close to the expectation. This work is also a rst study of how well can the bene t of a randomized on-line algorithm be concentrated around its expectation. Combinatorial Optimization Problems in Telecommunication Martin Grotschel Deregulation has resulted in a worldwide boom in the telecommunication industry. Competition leads to strict cost and quality management, which, in turn, o ers interesting perspectives for mathematics. In this talk I describe several fundamental operational and design problems coming up in telecommunication that can be modeled mathematically and yield large-scale combinatorial optimization problems. I focus on the design of low-cost networks that survive certain failure situations and on versions of the frequency assignment problem for mobile phone systems. I explain the mathematical models, the theory developed for their solution, and I report on computational results with data from practice. Algorithms for Call Scheduling and Wavelength Allocation Thomas Erlebach (joint work with K. Jansen, C. Kaklamanis and P. Persiano) Call scheduling means assigning starting times and paths to connection requests (calls) in a communication network. Each call speci es its bandwidth requirement and its duration. The sum of bandwidth requirements of simultaneously active calls using the same link must not exceed the capacity of that link. The goal is to complete all calls within the shortest possible time, i.e., to minimize the makespan. In the case of unit bandwidths and unit durations, this problem is equivalent to wavelength allocation in all-optical networks, where each call must be assigned a path and a wavelength such that calls using the same link are assigned di erent wavelengths. A minimum makespan schedule corresponds to a wavelength allocation with a minimum number of di erent wavelengths. After a short survey of known results regarding o -line and on-line approximation algorithms for call scheduling and wavelength allocation (both problems are NP-hard in most settings), we will focus on a wavelength allocation algorithm that assigns wavelengths to directed calls in trees using at most 5 3L wavelengths, where L is the maximum link load and a lower bound on the optimum number of wavelengths. The most important component of this algorithm is a subroutine for edge-coloring a bipartite graph in which the colors on certain edges have been xed beforehand. We show how to modify the original presentation of the algorithm in order to solve this constrained bipartite edge-coloring problem in the same time bounds as the unconstrained version. 10 On the Computation of Rectilinear Steiner Minimum Trees Michael Kaufmann (joint work with Uli Fo meier) In this talk, we report on our experiments for the computation of rectilinear Steiner minimum trees. After sketching the two main approaches, dynamic programming and branch and bound, we consider the concept of full components as the input of the two algorithms, and demonstrate the importance of a considerable reduction of the number of full components. We discuss several heuristics for the reduction and try some predictions for the expected running times for di erent problem sizes. Finger Search Trees with Constant Insertion Time Gerth S. Brodal We consider the problem of implementing nger search trees on the pointer machine, i.e., how to maintain a sorted list such that searching for an element x, starting the search at any arbitrary element f in the list, only requires time logarithmic in the distance between x and f in the list. We present the rst pointer based implementation of nger search trees allowing new elements to be inserted at any arbitrary position in the list in worst case constant time. Previously the best known insertion time on the pointer machine was O(log n), where n is the total length of the list. On a unit-cost RAM a constant insertion time has been achieved by Dietz and Raman by using standard techniques of packing small problem sizes into a constant number of machine words. Deletion of a list element is supported in O(log n) time, which matches the previous best bounds. Our data structure requires linear space. The Discrete 2-Center Problem Pankaj Agarwal Let P be a set of points in the plane. We wish to cover P by two congruent disks of the smallest possible radius and centered at two points of P . We present an O(n4=3 log5 n)-time algorithm for this problem. This is the rst subquadratic algorithm for this problem. Fast Hierarchical Clustering and Other Applications of Dynamic Closest Pairs David Eppstein (some of the work is joint with Je Erickson) We develop data structures for dynamic closest pair problems with arbitrary (not necessarily geometric) distance functions, based on a technique previously used by the author for Euclidean closest pairs. We show how to insert and delete objects from an n-object set, maintaining the closest pair, in O(n log2 n) time per update and O(n) space. With quadratic space, we can instead use a quadtree-like structure to achieve an optimal time 11 bound, O(n) per update. We apply these data structures to hierarchical clustering, greedy matching, TSP heuristics, collision detection, and straight skeleton construction, and discuss other potential applications in machine learning, Grobner bases, and local improvement algorithms for partition and placement problems. Experiments show our new methods to be faster in practice than previously used heuristics. GraphWin, A LEDA Data Type for Visualizing and Manipulating Graphs Stefan Naher The main goal of the new LEDA data type GraphWin is to o er a simple and e cient interactive tool for graph visualization and manipulation within LEDA's comfortable graph environment. For this purpose GraphWin combines the two types graph and window and forms a bridge between the various graph data types and algorithms on one side and the graphics interface of LEDA on the other side. The implementation of GraphWin is based on an observer design pattern for separating the graphical representation from the underlying graph data structure. GraphWin can easily be used in programs for constructing, displaying and manipulating graphs and for animating and debugging graph algorithms. We discuss some of the most important features of GraphWin. Simple User Interface The user interface of GraphWin was designed to be as simple and intuitive as possible. For instance, the user can easily create or move nodes and edges with the left mouse button and delete nodes and edges with the right button. An optional and customizable set of menues and buttons at the top of the window gives access to graph generators, modi ers, basic algorithms, embeddings, setup and le dialogs. Generators, Modi ers, and Tests Graphwin o ers a collection of graph generators, modi ers and tests. The generators include functions for constructing random, planar, complete, bipartite, grid graphs, . . . Graph modi ers change existing graphs (e.g., by removing or adding a certain set of edges) to t in one of these categories. Basic Algorithms and Embeddings The standard menu includes a choice of fundamental algorithms (topological sorting, depth rst search, breadth rst search, connected components, transitive closure, st-numbering, . . . ) and basic embedding algorithms. Parameterized Graphs Graphwin can display and manipulate data associated with the nodes and edges of LEDA's parameterized graph type GRAPH. When a graph window is opened for a graph G, say of type GRAPH, it can label every node v with the associated string G[v] and every edge e with the associated oating point number G[e]. Customization and Extensibility Most of the actions of GraphWin can be customized by de ning call-back functions. 12 So the user can de ne what happens if a node or edge is selected, moved, or deleted. This is very useful in the case that an additional data structure has to be maintained. For example, in the crossing reduction application, the di erent levels of the hierarchy are implemented by arrays. When dragging a node over another node (during a GraphWin edit operation) its position in the corresponding array has to be changed. It is also possible to restrict the set of possible modi cations. Approximating Minimum-Size k-Node Connected Spanning Subgraphs Joseph Cheriyan (joint work with Ramki Thurimella) An approximation algorithm is given for the NP-hard problem of nding a k-node connected spanning subgraph G0 of a given graph G = (V;E) such that G0 has the minimum number of edges. The algorithm achieves an approximation guarantee of 1 + 1 k and runs in time O(kjEj2). Polyhedral Combinatorics of the Quadratic Assignment Problem Volker Kaibel Many classicalNP-hard combinatorial optimization problems, like, e.g., the traveling salesman problem, the stable set problem, or the max cut problem, have been investigated from polyhedral points of view quite extensively. The structural insight gained this way lead to algorithms that can often solve instances of these problems very \e ciently". For example \real world" instances of the traveling salesman problem with several thousands cities can be often solved to optimality within several hours of CPU time. Although the quadratic assignment problem (QAP) is one of the most famousNP-hard combinatorial optimization problems, only a few results concerning the polytope that is naturally associated to the problem have been known so far. We give an overview of new polyhedral results on the QAP that we obtained exploiting di erent kinds of projection based techniques. These results include answers to the basic questions for the dimensions, the a ne hulls, and the \trivial facets" not only of the \natural" QAP-polytope, but also of several variants of it, which are associated especially to \symmetric" or \sparse" instances, or to instances with \less objects than locations". Moreover, we present the rst large class of facets for these polytopes, and show that the corresponding inequalities can be utilized for cutting plane procedures very e ectively. GraVis, A Dynamically Extensible Platform for Interactive Graph Algorithms Harald Lauer Interactive layout techniques are gaining in signi cance both in research and practical applications. GraVis o ers the functionality necessary for the e ective development and employment of dynamic layout algorithms. GraVis is also a complete and powerful interactive graph visualization system, supporting the integration into practical and research 13 applications. These features are derived from an object-oriented design, realizing dynamic extensibility and the exibility to integrate new concepts like multi-user/groupware support. We will present the design of GraVis, its features and describe the realization of the extension mechanism. Finally, a demonstration of the current version of GraVis will give an impression of its intuitive user interface, as well as the overall e ciency and usability. Optimal Su x Tree Construction with Large Alphabets Martin Farach The su x tree of a string is the fundamental data structure of combinatorial pattern matching. Weiner, who introduced the data structure, gave an O(n) time algorithm algorithm for building the su x tree of an n character string drawn from a constant size alphabet. In the comparison model, there is a trivial (n log n) time lower bound based on sorting, and Weiner's algorithm matches this bound trivially. Since Weiner's paper, the main open question has been how to deal with integer alphabets. There is no super-linear lower bound, and the fastest known algorithm was the O(n log n) time comparison based algorithm. We settle this open problem by closing the gap: we build su x trees in linear time for integer alphabet. Exact and Heuristic Algorithms for the Fleet Assignment Problem Stefan Tschoke The eet assignment problem is one of a series of optimization problems occuring in airline industry operations, beginning with market modelling and ight scheduling followed by eet assignment, crew pairing and crew rostering. The eet assignment has usually to be done six month before day of operation and is planned on a weekly basis. It is not unusual that a large internationally operating airline o ers more than 100.000 possible itineraries on 10.000 legs a week working with more than 200 aircrafts of 20 di erent subtypes ( eet) on 150 airports. It can be shown that a eet assignment with more than two di erent given types of aircraft ( eet) is NP-complete. There are a lot of hard and soft constraints. A eet assignment is only valid if the aircrafts are assigned on round-trips. Additional restrictions are the passenger capacity, range of the aircrafts, maintenance periods, crew restrictions, take-o and landing time-slots etc. Most of the known approaches of the eet assignment are based on integer programming models of the problem and are using LP relaxations and column generation methods. To reduce the size of the huge LPs or IPs eetings are often solved only on daily basis. These approaches usually minimize the operational costs but are not maximizing the pro t. We developed such an exact approach for solving smaller instances and and for upper bounds on the pro t. Our heuristic approach has two phases, rstly generating rotational elements and secondly assigning an aircraft type to every rotational element guaranteeing rotations for the whole planning period. We maximize the pro t instead of minimizing costs. The di erence 14 is that number of passengers on a certain leg is not independent of the passenger capacity, i.e., if passengers are rejected (the number of estimated passengers is higher than the aircraft capacity) this has impact on the revenue of other legs because passengers will look for alternative ights (spill-o and recover model). We tested our algorithm on real world data (8000 legs, 250 aircrafts, 200.000 itinararies) provided by a large german airline. To be part of an interactive decision support system, the eet assignment has to be solved not only once in six months but many times. Therefore we also parallelized our algorithm and could reduce the computational times signi cantly. Linear Programming with Exact Arithmetic Bernd Gartner We describe a new exact-arithmetic approach to linear programming when the number of variables n is much larger than the number of constraints m (or vice versa). The algorithm is an implementation of the simplex method which combines exact (multiple precision) arithmetic with inexact ( oating point) arithmetic, where the number of exact arithmetic operations is small and usually bounded by a function of min(n;m). Combining this with a \partial pricing" scheme (based on a result by Clarkson which is particularly tuned for the problems under consideration, we obtain a correct and practically e cient C++ algorithm that even competes with the inexact state-of-the-art solver CPLEX for small values of min(n;m). Arrangements of Pseudolines: Higher Bruhat Orders, Triangles and k-Sets Stefan Felsner (joint work with Helmut Alt, Klaus Kriegel and Helmut Weil) In computational geometry a good understanding of arrangements often aids discovery and analysis of e cient algorithms. We provide a combinatorial framework for the study of simple Euclidean arrangements of pseudolines. They correspond bijectively to functions a : [n] 3 ! f+; g obeying a monotonicity condition on every 4-element subset of [n]. These functions are the elements of the higher Bruhat order B(n; 2). The Bruhat order B(n; k) represents a class of arrangements in Rk. The minimum degree in B(n; 2) is the minimal number of triangles in simple arrangements. We show that simple arrangements have at least n 2 triangles while non-simple arrangements can have as few as 2n=3 triangles but not less. Finally, we give a surprising new proof for the old n3=2 bound for the complexity of the middle level of an arrangement. A Polylogarithmic Approximation Algorithm for the Group Steiner Tree Problem Naveen Garg (joint work with Goran Konjevod and R. Ravi) The group Steiner tree problem is a generalization of the Steiner tree problem where we are given several subsets (groups) of vertices in a weighted graph, and the goal is to nd a 15 minimum-weight connected subgraph containing at least one vertex from each group. The problem was introduced by Reich and Widmayer and nds applications in VLSI design. The group Steiner tree problem generalizes the set cover problem, and hence a logarithmic approximation factor is the best possible unless P=NP. We give a randomized O(log4 n)-approximation algorithm for the group Steiner tree problem. The best previous performance guarantee was (1 + lnk 2 )pk, where k is the number of groups (Bateman, Helvig, Robins and Zelikovsky) We use the result of Bartal on probabilistic approximation of nite metric spaces by tree metrics to reduce the problem to one in a tree metric. To nd a solution on a tree, we use a variant of randomized rounding. Shortest Path and Connected Components in Secondary Memory Kurt Mehlhorn (joint work with Andreas Crauser and Ulrich Meyer) In this report we investigate the I/O complexity of computing the single source shortest path on a input graph with non-negative edge weights and nding the connected components of a undirected graph. We present an algorithm that uses O(ND + m DB logS=B mB ) I/O with high probability for a large class of random graphs, where n;m are the number of nodes respectively the number of edges of the graph, S is the size of available internal memory, B is the size of block transfer and D is the number of independent parallel disks; D is constrained to be O(qn=d). For the problem of computing connected components of undirected graphs we introduce a randomized algorithm that computes the connected components in O(mB logS=B mB ) expected I/O. The proposed algorithm can be used to compute the biconnected components of an undirected graph with the same number of I/Os.